home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / Tools / Mesa-1.2.1 / samples / speed.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-07-05  |  8.5 KB  |  411 lines
  1. /*
  2.  * Copyright (c) 1991, 1992, 1993 Silicon Graphics, Inc.
  3.  *
  4.  * Permission to use, copy, modify, distribute, and sell this software and
  5.  * its documentation for any purpose is hereby granted without fee, provided
  6.  * that (i) the above copyright notices and this permission notice appear in
  7.  * all copies of the software and related documentation, and (ii) the name of
  8.  * Silicon Graphics may not be used in any advertising or
  9.  * publicity relating to the software without the specific, prior written
  10.  * permission of Silicon Graphics.
  11.  *
  12.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF
  13.  * ANY KIND,
  14.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
  15.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
  16.  *
  17.  * IN NO EVENT SHALL SILICON GRAPHICS BE LIABLE FOR
  18.  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  19.  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  20.  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF
  21.  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  22.  * OF THIS SOFTWARE.
  23.  */
  24.  
  25. #define _HPUX_SOURCE
  26.  
  27. #include <stdio.h>
  28. #include <string.h>
  29. #include <unistd.h>
  30. #include <stdlib.h>
  31. #include "tk.h"
  32.  
  33. #ifdef __unix
  34. #include <sys/times.h>
  35. #include <sys/param.h>
  36. #endif
  37.  
  38.  
  39. #define GAP 10
  40. #define ROWS 1
  41. #define COLS 4
  42.  
  43.  
  44. GLenum rgb, doubleBuffer, directRender, windType;
  45. GLint windW, windH;
  46.  
  47. GLint boxW, boxH;
  48.  
  49. GLenum antialiasing = GL_FALSE;
  50. GLenum depthTesting = GL_FALSE;
  51. GLenum fogging = GL_FALSE, niceFogging = GL_FALSE;
  52. GLenum lighting = GL_FALSE;
  53. GLenum shading = GL_FALSE;
  54. GLenum texturing = GL_FALSE;
  55.  
  56. GLint repeatCount = 1000;
  57. GLint loopCount = 100;
  58.  
  59. GLubyte texture[4*3] = {
  60.     0xFF, 0, 0, 0, 0, 0,
  61.     0, 0, 0, 0, 0xFF, 0,
  62. };
  63.  
  64.  
  65. static void SetWindSize(int width, int height)
  66. {
  67.  
  68.     windW = (GLint)width;
  69.     windH = (GLint)height;
  70. }
  71.  
  72. static GLenum Key(int key, GLenum mask)
  73. {
  74.  
  75.     switch (key) {
  76.       case TK_ESCAPE:
  77.     tkQuit();
  78.       case TK_a:
  79.     antialiasing = !antialiasing;
  80.     break;
  81.       case TK_d:
  82.     depthTesting = !depthTesting;
  83.     break;
  84.       case TK_f:
  85.     fogging = !fogging;
  86.     break;
  87.       case TK_F:
  88.     niceFogging = !niceFogging;
  89.     break;
  90.       case TK_s:
  91.     shading = !shading;
  92.     break;
  93.       case TK_t:
  94.     texturing = !texturing;
  95.     break;
  96.       default:
  97.     return GL_FALSE;
  98.     }
  99.     return GL_TRUE;
  100. }
  101.  
  102. static void Viewport(GLint row, GLint column)
  103. {
  104.     GLint x, y;
  105.  
  106.     boxW = (windW - (COLS + 1) * GAP) / COLS;
  107.     boxH = (windH - (ROWS + 1) * GAP) / ROWS;
  108.  
  109.     x = GAP + column * (boxW + GAP);
  110.     y = GAP + row * (boxH + GAP);
  111.  
  112.     glViewport(x, y, boxW, boxH);
  113.  
  114.     glMatrixMode(GL_PROJECTION);
  115.     glLoadIdentity();
  116.     gluOrtho2D(-boxW/2, boxW/2, -boxH/2, boxH/2);
  117.     glMatrixMode(GL_MODELVIEW);
  118.  
  119.    /* glEnable(GL_SCISSOR_TEST);*/
  120.     glScissor(x, y, boxW, boxH);
  121. }
  122.  
  123. static double Now(void)
  124. {
  125. #ifdef __unix
  126.     struct tms tm;
  127.     clock_t clk;
  128.  
  129.     clk = times(&tm);
  130.     return (double)clk / (double)HZ;
  131. #else
  132.     return 0;
  133. #endif
  134. }
  135.  
  136. static void Report(const char *msg, float elapsed)
  137. {
  138.  
  139.     if (elapsed == 0.0) {
  140.     printf("%s per second: Unknown, elapsed time is zero\n", msg);
  141.     } else {
  142.     printf("%s per second: %g\n", msg, repeatCount*loopCount/elapsed);
  143.     }
  144. }
  145.  
  146. static void Points(void)
  147. {
  148.     GLint i, j;
  149.     float v1[3];
  150.     double start;
  151.  
  152.     start = Now();
  153.     for (i = 0; i < repeatCount; i++) {
  154.     v1[0] = 10;
  155.     v1[1] = 10;
  156.     v1[2] = 10;
  157.     glBegin(GL_POINTS);
  158.         for (j = 0; j < loopCount; j++) {
  159.         glVertex2fv(v1);
  160.         }
  161.     glEnd();
  162.     }
  163.     glFinish();
  164.     Report("Points", Now()-start);
  165. }
  166.  
  167. static void Lines(void)
  168. {
  169.     GLint i, j;
  170.     float v1[3], v2[3];
  171.     double start;
  172.  
  173.     start = Now();
  174.     for (i = 0; i < repeatCount; i++) {
  175.     v1[0] = 10;
  176.     v1[1] = 10;
  177.     v1[2] = 10;
  178.     v2[0] = 20;
  179.     v2[1] = 20;
  180.     v2[2] = 10;
  181.     glBegin(GL_LINES);
  182.         for (j = 0; j < loopCount; j++) {
  183.         glVertex2fv(v1);
  184.         glVertex2fv(v2);
  185.         }
  186.     glEnd();
  187.     }
  188.     glFinish();
  189.     Report("Lines", Now()-start);
  190. }
  191.  
  192. static void Triangles(void)
  193. {
  194.     GLint i, j;
  195.     float v1[3], v2[3], v3[3], t1[2], t2[2], t3[2];
  196.     double start;
  197.  
  198.     start = Now();
  199.  
  200.     v1[0] = 10;
  201.     v1[1] = 10;
  202.     v1[2] = 10;
  203.     v2[0] = 20;
  204.     v2[1] = 20;
  205.     v2[2] = 10;
  206.     v3[0] = 10;
  207.     v3[1] = 20;
  208.     v3[2] = 10;
  209.  
  210.     t1[0] = 0;
  211.     t1[1] = 0;
  212.     t2[0] = 1;
  213.     t2[1] = 1;
  214.     t3[0] = 0;
  215.     t3[1] = 1;
  216.  
  217.     for (i = 0; i < repeatCount; i++) {
  218.     glBegin(GL_TRIANGLES);
  219.         for (j = 0; j < loopCount; j++) {
  220.         if (texturing) {
  221.             glTexCoord2fv(t1);
  222.         }
  223.         glVertex2fv(v1);
  224.         if (texturing) {
  225.             glTexCoord2fv(t2);
  226.         }
  227.         glVertex2fv(v2);
  228.         if (texturing) {
  229.             glTexCoord2fv(t3);
  230.         }
  231.         glVertex2fv(v3);
  232.         }
  233.     glEnd();
  234.     }
  235.     glFinish();
  236.     Report("Triangles", Now()-start);
  237. }
  238.  
  239. static void Rects(void)
  240. {
  241.     GLint i, j;
  242.     float v1[2], v2[2];
  243.     double start;
  244.  
  245.     start = Now();
  246.     for (i = 0; i < repeatCount; i++) {
  247.     v1[0] = 10;
  248.     v1[1] = 10;
  249.     v2[0] = 20;
  250.     v2[1] = 20;
  251.     for (j = 0; j < loopCount; j++) {
  252.         glRectfv(v1, v2);
  253.     }
  254.     }
  255.     glFinish();
  256.     Report("Rects", Now()-start);
  257. }
  258.  
  259. static void Draw(void)
  260. {
  261.  
  262.     glClearColor(0.0, 0.0, 0.0, 0.0);
  263.     glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
  264.  
  265.     TK_SETCOLOR(windType, TK_YELLOW);
  266.  
  267.     if (antialiasing) {
  268.     glBlendFunc(GL_SRC_ALPHA, GL_ZERO);
  269.     glEnable(GL_BLEND);
  270.  
  271.     glEnable(GL_POINT_SMOOTH);
  272.     glEnable(GL_LINE_SMOOTH);
  273.     glEnable(GL_POLYGON_SMOOTH);
  274.     printf("antialiasing: on\n");
  275.     }
  276.     else {
  277.        glDisable(GL_BLEND);
  278.        glDisable(GL_POINT_SMOOTH);
  279.        glDisable(GL_LINE_SMOOTH);
  280.        glDisable(GL_POLYGON_SMOOTH);
  281.        printf("antialiasing: off\n");
  282.     }
  283.     if (depthTesting) {
  284.     glEnable(GL_DEPTH_TEST);
  285.     printf("depthtest: on\n");
  286.     }
  287.     else {
  288.        glDisable(GL_DEPTH_TEST);
  289.        printf("depthtest: off\n");
  290.     }
  291.     if (fogging) {
  292.     glEnable(GL_FOG);
  293.     glHint(GL_FOG_HINT, (niceFogging) ? GL_NICEST : GL_FASTEST);
  294.     printf("fog: on\n");
  295.     }
  296.     else {
  297.        glDisable(GL_FOG);
  298.        printf("fog: off\n");
  299.     }
  300.     if (lighting) {
  301.     static GLfloat ambient[4] = {1, 0.5, 0.5, 0};
  302.  
  303.     glEnable(GL_NORMALIZE);
  304.     glNormal3f(1.0, 1.0, 1.0);
  305.     glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
  306.     glEnable(GL_LIGHTING);
  307.     glEnable(GL_LIGHT0);
  308.     printf("lighting: on\n");
  309.     }
  310.     else {
  311.        glDisable( GL_LIGHTING );
  312.        printf("lighting: off\n");
  313.      }
  314.     if (shading) {
  315.        glShadeModel(GL_SMOOTH);
  316.        printf("shading: smooth\n");
  317.     }
  318.     else {
  319.        glShadeModel(GL_FLAT);
  320.        printf("shading: flat\n");
  321.     }
  322.     if (texturing) {
  323.     static GLfloat modulate[1] = {GL_DECAL};
  324.     static GLfloat clamp[1] = {GL_CLAMP};
  325.     static GLfloat linear[1] = {GL_LINEAR};
  326.  
  327.     glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  328.     glTexImage2D(GL_TEXTURE_2D, 0, 3, 2, 2, 0, GL_RGB, GL_UNSIGNED_BYTE,
  329.              (GLvoid *)texture);
  330.     glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, modulate);
  331.     glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, clamp);
  332.     glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, clamp);
  333.     glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, linear);
  334.     glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, linear);
  335.     glEnable(GL_TEXTURE_2D);
  336.     printf("texturing: on\n");
  337.     }
  338.     else {
  339.        glDisable( GL_TEXTURE_2D );
  340.        printf("texturing: off\n");
  341.      }
  342.  
  343.     Viewport(0, 0); Points();
  344.     Viewport(0, 1); Lines();
  345.     Viewport(0, 2); Triangles();
  346.     Viewport(0, 3); Rects();
  347.  
  348.     glFlush();
  349.  
  350.     if (doubleBuffer) {
  351.     tkSwapBuffers();
  352.     }
  353. }
  354.  
  355. static GLenum Args(int argc, char **argv)
  356. {
  357.     GLint i;
  358.  
  359.     rgb = GL_TRUE;
  360.     doubleBuffer = GL_FALSE;
  361.     directRender = GL_TRUE;
  362.  
  363.     for (i = 1; i < argc; i++) {
  364.     if (strcmp(argv[i], "-ci") == 0) {
  365.         rgb = GL_FALSE;
  366.     } else if (strcmp(argv[i], "-rgb") == 0) {
  367.         rgb = GL_TRUE;
  368.     } else if (strcmp(argv[i], "-sb") == 0) {
  369.         doubleBuffer = GL_FALSE;
  370.     } else if (strcmp(argv[i], "-db") == 0) {
  371.         doubleBuffer = GL_TRUE;
  372.     } else if (strcmp(argv[i], "-dr") == 0) {
  373.         directRender = GL_TRUE;
  374.     } else if (strcmp(argv[i], "-ir") == 0) {
  375.         directRender = GL_FALSE;
  376.     } else {
  377.         printf("%s (Bad option).\n", argv[i]);
  378.         return GL_FALSE;
  379.     }
  380.     }
  381.     return GL_TRUE;
  382. }
  383.  
  384. void main(int argc, char **argv)
  385. {
  386.  
  387.     if (Args(argc, argv) == GL_FALSE) {
  388.     tkQuit();
  389.     }
  390.  
  391.     windW = 600;
  392.     windH = 300;
  393.     tkInitPosition(0, 0, windW, windH);
  394.  
  395.     windType = TK_ALPHA | TK_DEPTH;
  396.     windType |= (rgb) ? TK_RGB : TK_INDEX;
  397.     windType |= (doubleBuffer) ? TK_DOUBLE : TK_SINGLE;
  398.     windType |= (directRender) ? TK_DIRECT : TK_INDIRECT;
  399.     tkInitDisplayMode(windType);
  400.  
  401.     if (tkInitWindow("Speed Test") == GL_FALSE) {
  402.     tkQuit();
  403.     }
  404.  
  405.     tkExposeFunc(SetWindSize);
  406.     tkReshapeFunc(SetWindSize);
  407.     tkKeyDownFunc(Key);
  408.     tkDisplayFunc(Draw);
  409.     tkExec();
  410. }
  411.